prompts/example1/sys_prompt_tmpl.txt (1)

21-26: Temporal awareness rules are well-structured.

The new Rule 4 provides clear guidance for handling temporal context. The instructions cover document metadata usage, prioritization of recent documents, conflict resolution, and recency communication.

Note: A past review suggested simplifying line 24 to reduce redundancy. The current version is more explicit but slightly verbose. Consider if the additional detail is necessary.

openrag/utils/temporal.py (2)

40-50: Consider renaming english_patterns to clarify its purpose.

As noted in a previous review, the variable name english_patterns could be misleading since it includes patterns for multiple languages (French, German, Spanish, Italian, Portuguese). A name like multilingual_fallback_patterns or common_language_patterns would better describe its purpose.

-        # English patterns for backward compatibility
-        self.english_patterns = {
+        # Multilingual fallback patterns for common temporal expressions
+        self.multilingual_patterns = {
             r'\b(today|aujourd\'hui|heute|hoy|oggi|hoje)\b': lambda: self._get_today(),
             r'\b(yesterday|hier|ayer|ieri|ontem)\b': lambda: self._get_yesterday(),
             r'\b(last|past|recent)\b': lambda: self._get_last_n_days(30),
         }

Note: Update references in extract_temporal_filter accordingly.

---

174-210: High false-positive risk in relative time extraction - previously flagged.

As noted in a previous review, this heuristic is prone to false positives. Queries like "summarize documents about 7 Eleven acquisition" or "5 star reviews" will incorrectly trigger temporal filtering for 7 or 5 days respectively.

The pattern (\d+)\s*\w+|\w+\s+(\d+) is too permissive—it matches any number adjacent to any word.

Consider:

1. Requiring specific time-unit keywords (days, weeks, months, años, jours, etc.)
2. Adding a confidence threshold or validation
3. Making this extraction opt-in via configuration

docs/content/docs/documentation/data_model.md (1)

109-149: Clarify temporal filter semantics (UTC + inclusivity) for better alignment with implementation

The temporal schema description is solid, but it would help to explicitly state that:

• All stored timestamps are normalized to UTC (even if represented as +00:00 instead of Z), and
• Whether *_after / *_before are inclusive (>=/<=) or exclusive bounds.

This avoids confusion when users try to match query behavior to the documented model and Milvus filter expressions, especially when mixing manual temporal_filter with other metadata filters.

docker-compose.yaml (1)

7-7: Prefer versioned Docker tags over :latest for reproducible deployments

Switching to linagoraai/openrag:latest and linagoraai/indexer-ui:latest is convenient for dev, but it makes production deployments non-deterministic and harder to roll back.

Consider:

• Pinning to explicit versions (or at least a well-defined channel tag), and/or
• Documenting that :latest is intended only for local/dev use.

Also applies to: 60-60

openrag/components/indexer/chunker/chunker.py (1)

5-5: Per‑chunk indexed_at metadata looks correct; consider DRYing and reusing a single timestamp

The new chunk_meta construction in all three splitters:

chunk_meta = {
    **metadata,
    "page": start_page,
    "indexed_at": datetime.now(timezone.utc).isoformat(),
}
filtered_chunks.append(Document(page_content=chunk_w_context, metadata=chunk_meta))

• Correctly:
  • Preserves existing metadata,
  • Sets page to the chunk’s start page, and
  • Overrides any incoming indexed_at with the current UTC time, matching the PR’s “ignore request-provided indexed_at” requirement.

Two optional refinements:

1. Compute a single indexed_at_ts = datetime.now(timezone.utc).isoformat() once per split_document call and reuse it for all chunks to:

   • Avoid tiny timestamp drift between chunks, and
   • Save repeated datetime.now calls.

2. Extract a small helper (e.g., _build_chunk_meta(metadata, start_page, indexed_at_ts)) to avoid duplicating the same dict construction across the three splitters.

Also applies to: 239-244, 356-361, 461-466

openrag/components/utils.py (1)

121-156: Replace bare except in format_date with a narrower exception (and optionally reuse shared temporal utilities)

The new format_date helper is useful, but this pattern:

def format_date(iso_date: str) -> str:
    try:
        from datetime import datetime
        dt = datetime.fromisoformat(iso_date.replace('Z', '+00:00'))
        return dt.strftime("%Y-%m-%d %H:%M")
    except:
        return iso_date

has two drawbacks:

• The bare except: will also swallow critical exceptions (e.g., KeyboardInterrupt, SystemExit), and static analysis flags it (E722).
• Re-importing datetime on every call is unnecessary.

A safer version:

-from datetime import datetime
-
 def format_date(iso_date: str) -> str:
     """Convert ISO date to readable format: 2025-11-02 14:30"""
     try:
-        from datetime import datetime
-        dt = datetime.fromisoformat(iso_date.replace('Z', '+00:00'))
+        dt = datetime.fromisoformat(iso_date.replace("Z", "+00:00"))
         return dt.strftime("%Y-%m-%d %H:%M")
-    except:
+    except (ValueError, TypeError):
         return iso_date

…and add a single from datetime import datetime at module level if you want to avoid the local import entirely.

If you already have shared parsing/normalization logic in openrag/utils/temporal.py, you might also consider delegating to it here to keep temporal handling consistent in one place.

docs/content/docs/documentation/API.mdx (1)

222-229: Align temporal filtering examples between raw HTTP and OpenAI client usage

The temporal filtering section and examples are helpful, but there’s a subtle inconsistency:

• The curl example correctly shows metadata.temporal_filter as part of the JSON body.
• The first Python snippet under Temporal Filtering uses metadata={...} directly in client.chat.completions.create(...).
• The later “Example with Temporal Filtering” correctly uses extra_body={"metadata": {"temporal_filter": {...}}} for the OpenAI client.

To reduce confusion for users:

• Either update the earlier Python example to also use extra_body={"metadata": {...}}, or
• Explicitly distinguish:
  • Raw HTTP: metadata is a top-level JSON field.
  • OpenAI Python client: metadata goes inside extra_body.

This keeps the temporal_filter contract clear while matching how the OpenAI client actually passes through custom fields.

Also applies to: 233-259, 301-344

docs/content/docs/documentation/features_in_details.md (1)

87-131: Temporal Awareness documentation is clear; consider adding cross‑links for discoverability

The new Temporal Awareness section accurately reflects the temporal fields, scoring behavior, and configuration knobs introduced elsewhere (priority order, env vars, etc.).

As an optional improvement, consider:

• Linking to the API Temporal Filtering section and the Vector Database Schema (Milvus) data model section so readers can easily jump from the feature overview to request payload examples and the underlying schema.

openrag/components/reranker.py (1)

70-72: Consider logging at debug level instead of warning for common parsing scenarios.

The warning-level log for temporal score calculation errors may be noisy if documents frequently have malformed or missing date metadata. Consider using debug level, or only warn for unexpected error types.

         except Exception as e:
-            self.logger.warning(f"Error calculating temporal score: {e}")
+            self.logger.debug(f"Could not calculate temporal score, using neutral: {e}")
             return 0.5  # Neutral score on error

openrag/components/pipeline.py (3)

2-3: Remove unused json import.

The json module is imported but doesn't appear to be used in this file.

 import copy
-import json
 from datetime import datetime, timezone

---

46-51: Use explicit Optional type hint for temporal_filter parameter.

Per PEP 484 and the static analysis hint, implicit Optional (using = None without the type) should be explicit.

+from typing import Optional
+
+...
+
     async def retrieve_docs(
-        self, partition: list[str], query: str, use_map_reduce: bool = False, temporal_filter: dict = None
+        self, partition: list[str], query: str, use_map_reduce: bool = False, temporal_filter: Optional[dict] = None
     ) -> list[Document]:

---

183-186: Reconsider logging full system prompt content.

Logging the full system prompt at debug level (line 186) may expose the entire retrieved document context in logs. While useful for debugging, this could lead to large log entries and potential sensitive data exposure in production.

Consider logging only a truncated preview or removing this log in favor of the preceding log that includes prompt length and doc count.

         # Debug: log the formatted system prompt
         logger.debug("System prompt with context", prompt_length=len(system_prompt_content), doc_count=len(docs))
-        logger.debug("Full system prompt", content=system_prompt_content)
+        # Uncomment for local debugging only:
+        # logger.debug("Full system prompt", content=system_prompt_content)

openrag/utils/temporal.py (2)

62-81: Bare except clauses swallow all exceptions including system exits.

The bare except clauses here will catch KeyboardInterrupt, SystemExit, etc. While the intent is graceful fallback, consider catching specific exceptions.

     def _parse_numeric_date(self, match) -> Tuple[datetime, datetime]:
         """Parse numeric date: DD/MM/YYYY or MM/DD/YYYY"""
         # Try DD/MM/YYYY format first (more common internationally)
         try:
             day, month, year = int(match.group(1)), int(match.group(2)), int(match.group(3))
             if 1 <= month <= 12 and 1 <= day <= 31:
                 return self._get_specific_date(f"{year:04d}-{month:02d}-{day:02d}")
-        except:
+        except (ValueError, AttributeError):
             pass
         
         # Try MM/DD/YYYY format (US)
         try:
             month, day, year = int(match.group(1)), int(match.group(2)), int(match.group(3))
             if 1 <= month <= 12 and 1 <= day <= 31:
                 return self._get_specific_date(f"{year:04d}-{month:02d}-{day:02d}")
-        except:
+        except (ValueError, AttributeError):
             pass

---

221-256: Replace bare except with specific exception types.

The bare except clauses on lines 231 and 254 catch all exceptions. Use specific exception types for safer error handling.

         for pattern, parse_func in self.universal_patterns.items():
             match = re.search(pattern, query)
             if match:
                 try:
                     start, end = parse_func(match)
                     return {
                         'created_after': start.isoformat(),
                         'created_before': end.isoformat(),
                     }
-                except:
+                except (ValueError, AttributeError, TypeError):
                     continue

         for pattern, date_func in self.english_patterns.items():
             match = re.search(pattern, query_lower, re.IGNORECASE)
             if match:
                 try:
                     start, end = date_func()
                     return {
                         'created_after': start.isoformat(),
                         'created_before': end.isoformat(),
                     }
-                except:
+                except (ValueError, AttributeError, TypeError):
                     continue

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

openrag/utils/temporal.py (2)

89-101: Consider making date format preference configurable.

The current logic always prefers DD/MM/YYYY over MM/DD/YYYY for ambiguous dates (e.g., 01/02/2024 is interpreted as 1 February rather than 2 January). This bias may surprise users in regions that use MM/DD/YYYY conventions.

🔎 Suggested approach

Add a configuration parameter to control date format preference:

-    def __init__(self):
+    def __init__(self, prefer_day_first: bool = True):
+        self.prefer_day_first = prefer_day_first
         # Ordered: higher precision first

Then update _parse_numeric_date:

     def _parse_numeric_date(self, match):
         a, b, y = map(int, match.groups())
 
-        # Prefer DD/MM/YYYY if valid
-        # Note: I have no idea how to correctly disambiguate MM/DD/YYYY vs DD/MM/YYYY
-        if 1 <= b <= 12:
-            return self._specific_date(y, b, a)
-
-        # Fallback MM/DD/YYYY
-        if 1 <= a <= 12:
-            return self._specific_date(y, a, b)
+        if self.prefer_day_first:
+            # Try DD/MM/YYYY first
+            if 1 <= b <= 12 and 1 <= a <= 31:
+                return self._specific_date(y, b, a)
+            # Fallback MM/DD/YYYY
+            if 1 <= a <= 12 and 1 <= b <= 31:
+                return self._specific_date(y, a, b)
+        else:
+            # Try MM/DD/YYYY first
+            if 1 <= a <= 12 and 1 <= b <= 31:
+                return self._specific_date(y, a, b)
+            # Fallback DD/MM/YYYY
+            if 1 <= b <= 12 and 1 <= a <= 31:
+                return self._specific_date(y, b, a)
 
         raise ValueError

---

155-163: Consider using word boundaries for keyword matching.

The current substring matching (if word in q) could theoretically match keywords as parts of larger words, though this is unlikely for the keywords provided.

🔎 More robust approach using word boundaries

     def _extract_keywords(self, query: str):
         q = query.lower()
         for word, offset in self.keyword_ranges.items():
-            if word in q:
+            if re.search(r'\b' + re.escape(word) + r'\b', q):
                 day = datetime.now(timezone.utc) - timedelta(days=offset)
                 start = day.replace(hour=0, minute=0, second=0, microsecond=0)
                 end = day.replace(hour=23, minute=59, second=59, microsecond=999999)
                 return start, end
         return None

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro